#ifndef __M_SRV_H__
#define __M_SRV_H__
#include "db.hpp"
#include "util.hpp"
#include "mather.hpp"
#include "online.hpp"
#include "session.hpp"
#include "room.hpp"

#define WWWROOT "./wwwroot/"

class gobang_server
{
private:
    std::string _web_root; // 静态资源根目录 ./wwwroot/
    user_table _ut;
    online_manager _om;
    room_manager _rm;
    session_manager _sm;
    mather _mm;
    wsserver_t _wssrv;
private:
    void file_handler(wsserver_t::connection_ptr& con)
    {
        // 静态资源请求
        // 获取请求uri资源路径, 了解客户端请求的页面文件名称
        websocketpp::http::parser::request req = con->get_request();
        std::string uri = req.get_uri();
        // 组合出文件的实际路径, 相对根目录+uri
        std::string realpath = _web_root + uri;
        // 如果请求的是个目录, 增加一个后缀 login.html
        if (realpath.back() == '/')
        {
            realpath += "login.html";
        }
        // 读取文件内容
        std::string body;
        bool ret = file_util::read(realpath, body);
        //     文件不存在, 读取失败, 返回404
        if (ret == false)
        {
            body += "<html>";
            body += "<head>";
            body += "<meta charset='UTF-8'>";
            body += "</head>";
            body += "<body>";
            body += "<h1>Not Found </h1>";
            body += "</body>";
            body += "</html>";
            con->set_status(websocketpp::http::status_code::not_found);
        }
        // 设置响应正文
        con->set_status(websocketpp::http::status_code::ok);  // 不设置默认是500
        con->set_body(body);
    }

    void http_resp(wsserver_t::connection_ptr &con, bool result, 
                websocketpp::http::status_code::value code, 
                const std::string& reason)
    {   
            Json::Value resp_json;
            resp_json["result"] = result;
            resp_json["reason"] = reason;
            std::string resp_body;
            json_util::serialize(resp_json, resp_body);
            con->set_status(code);
            con->set_body(resp_body);
            con->append_header("Content-Type", "application/json");
            return;
    }

    void reg(wsserver_t::connection_ptr& con)
    {
        // 注册
        websocketpp::http::parser::request req = con->get_request();
        // 获取到请求正文
        std::string req_body = con->get_request_body();
        // 对正文json反序列化, 得到用户名和密码
        Json::Value login_info;
        bool ret = json_util::unserialize(req_body, login_info);
        if (ret == false)
        {
            DLOG("反序列化注册信息失败!");
            return http_resp(con, false, websocketpp::http::status_code::bad_request, 
                            "请求的正文格式错误");
        }
        // 进行数据库的用户新增操作
        if (login_info["usename"].isNull() || login_info["password"].isNull())
        {
            DLOG("用户名和密码不完整!");
            return http_resp(con, false, websocketpp::http::status_code::bad_request, 
                            "请输入用户名和密码");
        }

        ret = _ut.insert(login_info);
        if (ret == false)
        {
            DLOG("数据库插入数据失败!");
            return http_resp(con, false, websocketpp::http::status_code::bad_request, 
                            "用户名被占用");
        }

        //     成功了, 返回200
        return http_resp(con, true, websocketpp::http::status_code::ok, 
                            "注册成功");
        //     失败了, 返回400
    }

    void login(wsserver_t::connection_ptr& con)
    {
        // 登录
        // 获取请求正文, json反序列化, 得到用户名和密码
        websocketpp::http::parser::request req = con->get_request();
        // 获取到请求正文
        std::string req_body = con->get_request_body();
        // 对正文json反序列化, 得到用户名和密码
        Json::Value login_info;
        bool ret = json_util::unserialize(req_body, login_info);
        if (ret == false)
        {
            DLOG("反序列化登录信息失败!");
            return http_resp(con, false, websocketpp::http::status_code::bad_request, 
                            "请求的正文格式错误");
        }
        // 校验完整性, 数据库用户验证
        if (login_info["usename"].isNull() || login_info["password"].isNull())
        {
            DLOG("用户名和密码不完整!");
            return http_resp(con, false, websocketpp::http::status_code::bad_request, 
                            "请输入用户名和密码");
        }

        ret = _ut.login(login_info);
        if (ret == false)
        {
            // 如果验证失败, 返回404
            DLOG("用户名和密码错误!");
            return http_resp(con, false, websocketpp::http::status_code::bad_request, 
                            "用户名和密码错误");
        }        

        // 如果验证成功, 给客户端创建session
        uint64_t uid = login_info["id"].asUInt64();
        session_ptr ssp = _sm.create_session(uid, LOGIN);
        if (ssp.get() == nullptr)
        {
            DLOG("创建会话失败!");
            return http_resp(con, false, websocketpp::http::status_code::bad_request, 
                            "创建会话失败");
        }
        // 设置session过期时间
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
        // 设置响应头部, setcookie,将session通过cookie返回
        std::string cookie_ssid = "SSID=" + std::to_string(ssp->ssid());
        con->append_header("Set-Cookie", cookie_ssid);
        return http_resp(con, true, websocketpp::http::status_code::ok, 
                            "登录成功");
    }

    bool get_cookie_val(const std::string& cookie_str, const std::string& key, std::string& val)
    {
        // cookie: SSID=XXX; path=/
        // 以; 作为间隔, 得到各个单个的cookie信息
        std::string sep = "; ";
        std::vector<std::string> cookie_arr;
        string_util::split(cookie_str, sep, cookie_arr);
        for (auto str : cookie_arr)
        {
            // 对单个cookie字符串, 以=为间隔分割, 得到key和value
            std::vector<std::string> tmp_arr;
            string_util::split(str, "=", tmp_arr);
            if (tmp_arr.size() != 2){
                continue;
            }

            if (tmp_arr[0] == key)
            {
                val = tmp_arr[1];
                return true;
            }
        }

        return false;
    }

    void info(wsserver_t::connection_ptr& con)
    {
        // 用户信息
        // 获取请求中的cookie, 从cookie获取ssid
        std::string cookie_str = con->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            // 如果没有cookie, 返回错误, 重新登录
            return http_resp(con, false, websocketpp::http::status_code::bad_request, "找不到cookie信息，请重新登录");
        }

        // 从cookie取出ssid
        std::string ssid_str;
        bool ret = get_cookie_val(cookie_str, "SSID", ssid_str);
        if (ret == false)
        {
            // cookie中没有ssid, 返回错误, 没有ssid信息, 重新登录
            return http_resp(con, false, websocketpp::http::status_code::bad_request, "找不到cookie信息，请重新登录");
        }
        // 在session管理中查找对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if (ssp.get() == nullptr)
        {
            // 没有ssid, 返回错误, 没有ssid信息, 重新登录
            return http_resp(con, false, websocketpp::http::status_code::bad_request, "登录过期，请重新登录");
        }
        // 数据库取出用户信息, 进行序列化发送
        uint64_t uid = ssp->get_user();
        Json::Value use_info;
        ret = _ut.select_by_id(uid, use_info);
        if (ret == false)
        {
            // 获取用户信息失败, 找不到用户信息
            return http_resp(con, false, websocketpp::http::status_code::bad_request, "找不到用户信息，请重新登录");
        }

        std::string body;
        json_util::serialize(use_info, body);
        con->set_body(body);
        con->append_header("Content-Type", "application/json");
        con->set_status(websocketpp::http::status_code::ok);
        // 刷新session过期时间
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
    }

    void http_callback(websocketpp::connection_hdl hd1)
    {
        wsserver_t::connection_ptr con = _wssrv.get_con_from_hdl(hd1);
        websocketpp::http::parser::request req = con->get_request();
        std::string method = req.get_method();
        std::string uri = req.get_uri();

        if (method == "POST" && uri == "/reg")
        {
            return reg(con);
        }
        else if(method == "POST" && uri == "/login")
        {
            return login(con);
        }
        else if (method == "GET" && uri == "/info")
        {
            return info(con);
        }
        else
        {
            return file_handler(con);
        }
    }

    void ws_resp(wsserver_t::connection_ptr con, Json::Value& resp)
    {
        std::string body;
        json_util::serialize(resp, body);
        con->send(body);
    }

    session_ptr get_session_by_cookie(wsserver_t::connection_ptr con)
    {
        // 登录验证, 判断当前客户端是否成功登录
        Json::Value err_resp;
        // 获取cookie, 获取ssid
        std::string cookie_str = con->get_request_header("Cookie");
        // 如果没有cookie, 返回错误, 重新登录
        if (cookie_str.empty())
        {
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "没有找到cookie信息, 重新登录";
            err_resp["result"] = false;
            ws_resp(con, err_resp);
            return session_ptr();
        }
        // 从cookie取出ssid
        std::string ssid_str;
        bool ret = get_cookie_val(cookie_str, "SSID", ssid_str);
        if (ret == false)
        {
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "没有找到SSID信息, 重新登录";
            err_resp["result"] = false;
            ws_resp(con, err_resp);
            return session_ptr();
        }

        // 在session管理中查找对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if (ssp.get() == nullptr)
        {
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "没有找到session信息, 重新登录";
            err_resp["result"] = false;
            ws_resp(con, err_resp);
            return session_ptr();
        }

        return ssp;
    }

    void wsopen_game_hall(wsserver_t::connection_ptr con)
    {
        // 游戏大厅长连接建立成功
        // 登录验证, 判断当前客户端是否成功登录
        Json::Value err_resp;
        session_ptr ssp = get_session_by_cookie(con);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 判断当前客户端是否重复登录
        if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "玩家重新登录";
            err_resp["result"] = false;
            return ws_resp(con, err_resp);
        }
        // 将当前客户端以及连接加入到游戏大厅
        _om.enter_game_hall(ssp->get_user(), con);
        // 给客户端响应游戏大厅连接建立
        err_resp["optype"] = "hall_ready";
        err_resp["result"] = true;
        ws_resp(con, err_resp);
        // 设置session永久存在
        _sm.set_session_expire_time(ssp->get_user(), SESSION_FOREVER);
    }

    void wsopen_game_room(wsserver_t::connection_ptr con)
    {
        Json::Value resp_json;
        // 1. 获取当前客户端的session
        session_ptr ssp = get_session_by_cookie(con);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 2. 当前用户是否已经在在线用户管理的游戏房间或者游戏大厅中---在线用户管理
        if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            resp_json["optype"] = "room_ready";
            resp_json["reason"] = "玩家重复登录！";
            resp_json["result"] = false;
            return ws_resp(con, resp_json);
        }
        // 3. 判断当前用户是否已经创建好了房间 --- 房间管理
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if (rp.get() == nullptr)
        {
            resp_json["optype"] = "room_ready";
            resp_json["reason"] = "没有找到玩家的房间信息";
            resp_json["result"] = false;
            return ws_resp(con, resp_json);
        }
        // 4. 将当前用户添加到在线用户管理的游戏房间中
        _om.enter_game_room(ssp->get_user(), con);
        // 5. 将session重新设置为永久存在
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
        // 6. 回复房间准备完毕
        resp_json["optype"] = "room_ready";
        resp_json["result"] = true;
        resp_json["room_id"] = (Json::UInt64)rp->id();
        resp_json["uid"] = (Json::UInt64)ssp->get_user();
        resp_json["white_id"] = (Json::UInt64)rp->get_white_user();
        resp_json["black_id"] = (Json::UInt64)rp->get_black_user();
        return ws_resp(con, resp_json);
    }

    void wsopen_callback(websocketpp::connection_hdl hd1)
    {
        // 长连接建立成功后处理
        wsserver_t::connection_ptr con = _wssrv.get_con_from_hdl(hd1);
        websocketpp::http::parser::request req = con->get_request();
        std::string uri = req.get_uri();
        if (uri == "/hall")
        {
            // 游戏大厅的长连接
            return wsopen_game_hall(con);
        }
        else if (uri == "/room")
        {
            // 游戏房间的长连接
            return wsopen_game_room(con);
        }
    }

    void wsclose_game_hall(wsserver_t::connection_ptr con)
    {
        // 游戏大厅长连接断开的处理
        // 登录验证, 判断当前客户端是否成功登录
        session_ptr ssp = get_session_by_cookie(con);
        if (ssp.get() == nullptr)
        {
            return;
        }

        // 将玩家从游戏大厅移除
        _om.exit_game_hall(ssp->get_user());
        // 将session回复生命周期的管理, 设置定时销毁
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }

    void wsclose_game_room(wsserver_t::connection_ptr con)
    {
        // 获取会话, 识别客户端
        session_ptr ssp = get_session_by_cookie(con);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 将玩家从在线用户管理中移除
        _om.exit_game_room(ssp->get_user());
        // 将session回复生命周期的管理, 设置定时销毁
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
        // 将玩家从房间移除, 房间所有用户退出了就销毁房间
        _rm.remove_room_user(ssp->get_user());
    }

    void wsclose_callback(websocketpp::connection_hdl hd1)
    {
        // websocket连接断开前的处理
        wsserver_t::connection_ptr con = _wssrv.get_con_from_hdl(hd1);
        websocketpp::http::parser::request req = con->get_request();
        std::string uri = req.get_uri();
        if (uri == "/hall")
        {
            // 建立了游戏大厅的长连接
            return wsclose_game_hall(con);
        }
        else if (uri == "/room")
        {
            // 建立了游戏房间的长连接
            return wsclose_game_room(con);
        }
    }

    void wsmsg_game_hall(wsserver_t::connection_ptr con, wsserver_t::message_ptr msg)
    {
        // 身份验证, 当前客户端是哪个玩家
        Json::Value resp_json;
        session_ptr ssp = get_session_by_cookie(con);
        if (ssp.get() == nullptr)
        {
            return;
        }

        // 获取请求
        std::string req_body = msg->get_payload();
        Json::Value req_json;
        bool ret = json_util::unserialize(req_body, req_json);
        if (ret == false)
        {
            resp_json["result"] = false;
            resp_json["reason"] = "请求信息解析失败";
            return ws_resp(con, resp_json);
        }
        // 处理
        if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_start")
        {
            // 开始对战匹配, 将用户添加到匹配队列
            _mm.add(ssp->get_user());
            resp_json["optype"] = "match_start";
            resp_json["result"] = true;
            return ws_resp(con, resp_json);
        }
        else if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_stop")
        {
            // 停止匹配, 从匹配队列删除
            _mm.del(ssp->get_user());
            resp_json["optype"] = "match_stop";
            resp_json["result"] = true;
            return ws_resp(con, resp_json);
        }

        // 给客户端响应
        resp_json["optype"] = "unknow";
        resp_json["reason"] = "请求类型未知";
        resp_json["result"] = false;
        return ws_resp(con, resp_json);
    }

    void wsmsg_game_room(wsserver_t::connection_ptr con, wsserver_t::message_ptr msg)
    {
        // 获取客户端session, 识别客户端身份
        session_ptr ssp = get_session_by_cookie(con);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 获取客户端房间信息
        Json::Value resp_json;
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if (rp.get() == nullptr)
        {
            resp_json["optype"] = "unknow";
            resp_json["reason"] = "没有找到玩家的房间信息";
            resp_json["result"] = false;
            return ws_resp(con, resp_json);
        }
        // 消息反序列化
        Json::Value req_json;
        std::string req_body = msg->get_payload();
        bool ret = json_util::unserialize(req_body, req_json);
        if (ret == false)
        {
            resp_json["optype"] = "unknow";
            resp_json["reason"] = "请求解析失败";
            resp_json["result"] = false;
            return ws_resp(con, resp_json);
        }
        // 通过房间模块消息请求处理
        return rp->handle_request(req_json);
    }

    void wsmsg_callback(websocketpp::connection_hdl hd1, wsserver_t::message_ptr msg)
    {
        // websocket连接处理
        wsserver_t::connection_ptr con = _wssrv.get_con_from_hdl(hd1);
        websocketpp::http::parser::request req = con->get_request();
        std::string uri = req.get_uri();
        if (uri == "/hall")
        {
            // 建立了游戏大厅的长连接
            return wsmsg_game_hall(con, msg);
        }
        else if (uri == "/room")
        {
            // 建立了游戏房间的长连接
            return wsmsg_game_room(con, msg);
        }
    }

public:
    // 成员初始化，服务器回掉函数设置
    gobang_server(const std::string &web_root = WWWROOT)
        : _web_root(web_root), _rm(&_ut, &_om), _sm(&_wssrv),
          _mm(&_rm, &_ut, &_om)
    {
        // 设置日志级别，none什么日志都不打印
        _wssrv.set_access_channels(websocketpp::log::alevel::none);
        // 初始化调度器
        _wssrv.init_asio();
        _wssrv.set_reuse_addr(true);
        _wssrv.set_http_handler(std::bind(&gobang_server::http_callback, this, std::placeholders::_1));
        _wssrv.set_open_handler(std::bind(&gobang_server::wsopen_callback, this, std::placeholders::_1));
        _wssrv.set_close_handler(std::bind(&gobang_server::wsclose_callback, this, std::placeholders::_1));
        _wssrv.set_message_handler(std::bind(&gobang_server::wsmsg_callback, this, std::placeholders::_1, std::placeholders::_2));
    }
    // 启动服务器
    void start()
    {
        // 监听接口
        _wssrv.listen(8000);
        // 开始获取连接
        _wssrv.start_accept();
        DLOG("服务器开始运行！");
        // 开始运行
        _wssrv.run();
    }
};

#endif
